package org.jeecg.modules.classes.service.impl;

import com.alibaba.fastjson.JSONObject;
import org.apache.ibatis.annotations.Param;
import org.jeecg.common.system.api.ISysBaseAPI;
import org.jeecg.common.system.vo.DictModel;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecg.common.system.vo.SysTenantVo;
import org.jeecg.common.util.oConvertUtils;
import org.jeecg.modules.classes.entity.CouClass;
import org.jeecg.modules.classes.mapper.CouClassMapper;
import org.jeecg.modules.classes.service.ICouClassService;
import org.jeecg.modules.grade.entity.CouGrade;
import org.jeecg.modules.grade.service.ICouGradeService;
import org.jeecg.modules.student.entity.StuStudent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * @Description: cou_class
 * @author: baochangrong
 * @Date:   2022-02-10
 * @Version: V1.0
 */
@Service
public class CouClassServiceImpl extends ServiceImpl<CouClassMapper, CouClass> implements ICouClassService {

    @Autowired
    private CouClassMapper couClassMapper;
    @Autowired
    private ISysBaseAPI sysBaseAPI;
    @Autowired
    private ICouGradeService couGradeService;

    @Override
    public List<CouClass> queryAll(CouClass couClass) {
        return couClassMapper.queryAll(couClass);
    }

    @Override
    public List<CouClass> queryByGradeId(String gradeId) {
        return couClassMapper.queryByGradeId(gradeId);
    }

    @Override
    public CouClass getCouClassByUserID(String userId){
        return  couClassMapper.getCouClassByUserID(userId);
    }
    @Override
    public List<CouClass> getCouClassListByUser(@Param("loginUser") LoginUser loginUser, @Param("schoolYearId") String schoolYearId, @Param("semesterId") String semesterId){
        return  couClassMapper.getCouClassListByUser(loginUser,schoolYearId,semesterId);
    }
    @Override
    public boolean createUserByClassIds(String tenantId,String password,String ids, LoginUser loginUser,boolean force){
        if (oConvertUtils.isEmpty(ids)) {
            return false;
        }
//        Collection<CouClass> idList2 = idList;
//        List classList = listByIds(idList);
        List idsli = Arrays.asList(ids.split(","));

//        List<CouClass> classList = getClassListByIds(ids);
        List<CouClass>  classList = listByIds(idsli);

        SysTenantVo sysTenantVo = sysBaseAPI.getSysTenant(tenantId);

        //复制当前登录用户
        String oldUserJSON = JSONObject.toJSONString(loginUser);
        LoginUser newUser = JSONObject.parseObject(oldUserJSON,LoginUser.class);
        for(CouClass couClass : classList) {
            //判断是否为空，为空则执行，避免重复执行
            if( oConvertUtils.isEmpty(couClass.getUserId()) ) {
                //是否强制执行创建用户（已有用户，重新创建新用户）
                if(force){
                    couClass.setUserId(null);
                }
                if(oConvertUtils.isNotEmpty(couClass.getClassCode()) ){
                    newUser.setUsername(sysTenantVo.getPreCode() +couClass.getClassCode()); //优先使用租户后缀+班级号
                }
                else{
                    newUser.setUsername(sysTenantVo.getPreCode() +couClass.getClassName()); //其次使用租户后缀+班级名称
                }
                newUser.setPassword(password);
                newUser.setUserIdentity(6);//身份(字典码user_identity)：3老师 4班级  5家长 1.用户 2部门负责人 6虚拟班级
                newUser.setId(null);
                newUser.setWorkNo(couClass.getId());//工号：班级是虚拟账号，为减少非必要冲突，直接用id赋值

                newUser.setRealname(couClass.getClassName());
                newUser.setBirthday(couClass.getCreateTime());
                newUser.setOrgCode(couClass.getSysOrgCode());
                newUser.setSex(1);
                newUser.setPhone(couClass.getClassCode());
                newUser.setStatus(1); //正常，未冻结
                newUser.setDelFlag(0); //正常未删除
                newUser.setTelephone(couClass.getClassCode());
                newUser.setEmail(couClass.getClassCode());
                newUser.setDepartIds(sysBaseAPI.getDepartIdsByOrgCode(couClass.getSysOrgCode())); //部门编码设置部门id

//                String newuserId = sysBaseAPI.addUser(tenantId,newUser);
                sysBaseAPI.addUser(tenantId,newUser);

                //更新班级的用户id
                couClass.setUserId(newUser.getId());
                updateById(couClass);
            }
        }
        //全部执行成功
        return true;
    }

    /**
     * 批量升级班级名称：批量改名，把班级名称批量替换
     * @param ids 班级ids列表
     * @param gradeId 年级id
     * @param force 是否强制执行(重复升级时候强制升级会替换班级名称）
     * @return
     */
    @Override
    public boolean updateClassForGradeByIds(String ids, String gradeId,boolean force){

        List idsli = Arrays.asList(ids.split(","));
        return updateClassForGradeByIds( idsli,  gradeId, force);
    }
    /**
     * 批量升级班级名称：批量改名，把班级名称批量替换
     * @param ids 班级ids列表
     * @param gradeId 年级id
     * @param force 是否强制执行(重复升级时候强制升级会替换班级名称）
     * @return
     */
    @Override
    public boolean updateClassForGradeByIds(List ids, String gradeId,boolean force){
        CouGrade couGrade = couGradeService.getById(gradeId);
        if(oConvertUtils.isEmpty(couGrade) ){
            return false;
        }
        List<CouClass> couClassLists = this.listByIds(ids);
        for(CouClass couClass : couClassLists) {
            //判断是否已升级，未升级过则执行升级，避免重复执行，升级过则需要校验强制升级标识
            if(  couClass.getClassName().indexOf(couGrade.getGradeName()) >=0 || couClass.getClassNickname().indexOf(couGrade.getGradeAbbreviation()) >=0 ) {
                //名称已有年级信息，简称也有年级简称信息 说明已经升级过无需再次升级（除非强制重命名）
                if(!force ){
                    //不强制升级(对班级重命名)，跳到下次循环
                    continue;
                }
            }
            String className = getNewClassNameByClassNumber(couClass);
            //更新班级的名称和简称
            couClass.setClassName(couGrade.getGradeName()+className);
            couClass.setClassNickname(couGrade.getGradeAbbreviation()+className);
            updateById(couClass);
        }
        //全部执行成功
        return true;
    }

    /**
     * 根据年级id批量升级班级,把指定年级下的班级全升级为新的年级
     * @param oldGradeId 需要升级的旧的年级id
     * @param newGradeId 升级以后新的年级id
     * @param force 是否强制执行(重复升级时候强制升级会替换班级名称）
     * @return
     */
    @Override
    public boolean updateClassByGradeId(String oldGradeId, String newGradeId,boolean force){
        List<CouClass> oldCouClassLists =  queryByGradeId(oldGradeId);
        List ids = new ArrayList();
        for(CouClass couClass : oldCouClassLists) {
            ids.add(couClass.getId());
        }
        if(oConvertUtils.listIsEmpty(ids)){
            return false;
        }
        return updateClassForGradeByIds(ids,newGradeId,force);
    }

    /**
     * 根据班级号对应的字典码获取班级的名称
     * @param couClass
     * @return
     */
    @Override
    public String getNewClassNameByClassNumber(CouClass couClass){
        /* 查字典码设置字典text为班级名称*/
        String className = couClass.getClassNumber()+"班";
        List<DictModel> dictModelList = sysBaseAPI.getDictItems("class_number");
        if (dictModelList == null || dictModelList.size() < 1) {
//                new IllegalArgumentException("未查询到字典数据，请检查字典数据！");
            className = couClass.getClassNumber()+"班";
        }
        for (DictModel dictModel : dictModelList) {
            if (dictModel.getValue().equals(couClass.getClassNumber())) {
                className = dictModel.getText();
                break;
            }
        }
        return className;
    }
}
